package day15;


import java.util.Collections;

public class TestSingLeton {
    public static void main(String[] args) {
        User5 u = User5.get();
        User5 u2 = User5.get();
        User5 u3 = User5.get();
        System.out.println(u);
        System.out.println(u2);
        System.out.println(u3);
        //反射  创建对象  哪怕你构造私有  也可以使用
        //Class c = User5.class;

    }
}
//饿汉式:无论是否使用我都创建好
//class User{
//    static User u = new User();
//    //构造方法私有化
//    private User(){}
//    //提供一个公开的方法
//    public static User get(){
//        return u;
//    }
//}


//懒汉式：当你需要的单例对象比较大时，初始化比较耗费很多资源
//懒汉式：可以延迟初始化  提高性能

//class User2{
//    private static User2 u ;
//    public User2() {}
    //3.提供一个公开的方法 帮你返回一个对象
    //bug:适用于竞争比较小的时候
    //很可能有多个线程  同时进入if  就可能创建多个对象出来
//    public static User2 get() {
//        if(u == null) {  //第一次使用  这个时候 才创建对象
//            u=new User2();
//        }
//        return u;
//    }
    //解决方案：添加synchronized关键字,提供同步锁，排队使用线程
//    public static synchronized User2 get() {
//        if (u == null) {
//            u = new User2();
//        }
//        return u;
//    }
//}//效率低


//双重检索：如果需要多个线程环境下  延迟初始化对象时，它可以提供
//一种高效线程安全的懒加载
//class User2 {
//    private static User2 u;
//    private User2(){}
//    public static User2 get() {
//        if (u == null) { //是否为空
//            synchronized (User2.class) {
//                if (u == null) {
//                    u = new User2();
//                }
//            }
//        }
//        return u;
//    }
//}

//静态内部类方式：当需要延时初始化对象  而且还要保证线程安全
//静态内部类提供了一种比较优雅的实现方式
class User2 {
    //1.私有构造方法
    private User2(){}
    //2.私有静态内部类（里面负责把对象初始化）
    //负责了安全：由于静态内部类  只有被调用的时候，才会被加载
    //实现了懒加载，由于类加载过程
    //本身就是线程安全的  不需要额外的同步机制
    private static class User4Handler {
        private static final User2 u = new User2();
    }
    //3.提供公开静态的返回一个对象的方法
    public static User2 get(){
        return User4Handler.u;
    }
}

enum User5{
    ONE;
    private User5(){

    }
    public static User5 get(){
        return ONE;
    }
}